Path-Based Rules in Object-Oriented Programming

Object-oriented programming has recently emerged as one of the most important programming paradigms. While object-oriented programming clearly owes an intellectual debt to AI, it appears to be displacing some AI techniques, such as rule-based programming, from the marketplace. This need not be so as path-based rules|forward-chaining production rules that are restricted to follow pointers between objects||t into the object-oriented paradigm in a clean and elegant way. The combination of path-based rules and object-oriented programming should be useful in AI applications, and in the more general problem of transferring AI techniques to the larger computer science community. To this day, forward-chaining production rules remain largely unused in mainstream object-oriented applications. One reason for this lack of use is, of course, that many production rule systems (such as most versions of OPS (Cooper & Wogrin 1988), etc.) are written in LISP, and not in a major object-oriented language. However even in the new rule systems that claim integration with an object-oriented language, the integration is not adequate. Many of these rule systems (such as ART-IM (Inf 1987)) operate on their own data (working memory elements), not the objects of their base language. Applications thus need to move information between the working memory and object storage. Other systems (such as CERS (Miranker et al. 1993)) require special calls to bring objects of the language to the attention of the rule system. Although this means that informationdoes not need to be moved, it does require facilities outside of the object-oriented paradigm to control rules. The rules of object-oriented, production-rule systems (including the above systems, as well as ILOG) exist outside the object system, and thus are not organized in the same way as classes and objects. Further, even when the production rules directly operate on objects they still do not act like the rest of the system. In particular, production rules in all the above systems can form joins between unrelated objects, thus violating the locality assumptions implicit in object-oriented programming. However, rules have many uses within the object-oriented paradigm. Rules can be used to enforce in-variants, check constraints, react to events and states, update dependent objects, and even remove dangling pointers. Therefore, it would be useful to add rules to an object-oriented programming language in a manner that merges the rules naturally into the rest of the language. For this eeort to be a success, it must be easy for programmers who are …